package com.dzu.gulimall.search.thread;

import java.util.concurrent.*;

/**
 * @author ZhaoDong
 * @date 2022/4/24 17:45
 * @description 线程池测试
 */
public class ThreadTest3 {

    public static ExecutorService service = Executors.newFixedThreadPool(10);


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("start");

        /**
         * 线程串行化
         * 1、thenRunAsync   不能获取上一个任务结果、无返回值
         * .thenRunAsync(()->{
         *             System.out.println("qwe");
         *
         *         })
         *  2、thenAccept  能获取到上个任务返回值，无返回值
         *  .thenAccept(res -> {
         *             System.out.println(res);
         *         })
         *   3、
         *   thenApplyAsync  能获取、有返回值
         */
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            int i = 10;
            while (i > 0) {
                System.out.println(i);
                i /= 3;
            }
            return i;
        }, service).thenApplyAsync(res -> "hello" + res);

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            int i = 10;
            while (i > 0) {
                System.out.println(i);
                i /= 3;
            }
            return i;
        }, service);

        /**
         *    任务1和任务2都结束返回走任务3
         */
        future.runAfterBothAsync(future2, () -> {
            System.out.println("任务3");
        }, service);

        // 同上，但可以接受任务1和任务2的返回值，任务3并无返回值
        future.thenAcceptBothAsync(future2, (f, f2) -> {
            System.out.println(f);
            System.out.println(f2);
            System.out.println("任务3");
        }, service);

        // thenCombineAsync能接受任务1、任务2的返回值，又能有返回值
        CompletableFuture<String> future3 = future.thenCombineAsync(future2, (f, f2) -> {
            System.out.println(f);
            System.out.println(f2);
            System.out.println("任务3");
            return f + f2 + "任务三";

        }, service);

        /**
         * 任务1和任务2有一个完成就执行任务3的
         */
//        future.runAfterEitherAsync()  任务3无法接受返回值，自己也没有返回值
//        future.applyToEither()    可接受一个返回值（因为任务1和任务2只要有一个执行完成就会执行任务3.）任务3无返回值
//        future.applyToEitherAsync()  任务3能接受一个返回值，任务3也有返回值

        /**
         * 多任务组合
         */
//        CompletableFuture.allOf()
//        CompletableFuture.anyOf()
        System.out.println("end" + future3.get());

    }

    public static class Thread01 extends Thread {
        @Override
        public void run() {
            int i = 10;
            while (i > 0) {
                System.out.println(i);
                i /= 3;
            }
        }
    }

    public static class Runnable01 implements Runnable {

        @Override
        public void run() {
            int i = 10;
            while (i > 0) {
                System.out.println(i);
                i /= 3;
            }
        }
    }

    public static class Callable01 implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            int i = 10;
            while (i > 0) {
                i /= 3;
            }
            return i;
        }
    }

}
